{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:38.267831Z",
     "start_time": "2025-02-07T01:33:35.595017Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.6.0+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 加载数据",
   "id": "92a19dd204058cd"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:39.267157Z",
     "start_time": "2025-02-07T01:33:38.269182Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "id": "5b2bfa747663d0a0",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:43.051493Z",
     "start_time": "2025-02-07T01:33:39.268164Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:  # 遍历每张图片,img.shape=[1,28,28]\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205])  # 这里的均值和标准差是通过train_ds计算得到的\n",
    ")\n"
   ],
   "id": "a53fcd4642407473",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 定义模型\n",
    "这里没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ],
   "id": "64bf59205d3cfa1f"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "1. SELU 的数学定义\n",
    "SELU 激活函数的公式如下：\n",
    "\n",
    "SELU\n",
    "(\n",
    "x\n",
    ")\n",
    "=\n",
    "λ\n",
    "⋅\n",
    "{\n",
    "x\n",
    "if \n",
    "x\n",
    ">\n",
    "0\n",
    "α\n",
    "⋅\n",
    "(\n",
    "e\n",
    "x\n",
    "−\n",
    "1\n",
    ")\n",
    "if \n",
    "x\n",
    "≤\n",
    "0\n",
    "SELU(x)=λ⋅{ \n",
    "x\n",
    "α⋅(e \n",
    "x\n",
    " −1)\n",
    "​\n",
    "  \n",
    "if x>0\n",
    "if x≤0\n",
    "​\n",
    " \n",
    "其中：\n",
    "\n",
    "λ\n",
    "≈\n",
    "1.0507\n",
    "λ≈1.0507（缩放系数）。\n",
    "\n",
    "α\n",
    "≈\n",
    "1.6733\n",
    "α≈1.6733（负半轴的斜率）。\n",
    "\n",
    "2. SELU 的特性\n",
    "自归一化: SELU 能够自动将输入数据的均值和方差归一化到固定的范围，从而使得深层神经网络的训练更加稳定。\n",
    "\n",
    "非线性: SELU 是一种非线性激活函数，能够引入非线性特性，使神经网络能够学习复杂的模式。\n",
    "\n",
    "负值处理: 当输入为负值时，SELU 会输出一个非零的负值，这有助于保留更多的信息。\n",
    "\n",
    "3. SELU 的优点\n",
    "避免梯度消失和梯度爆炸: SELU 的缩放特性能够有效地控制梯度的传播，避免深层神经网络中的梯度消失和梯度爆炸问题。\n",
    "\n",
    "减少对 Batch Normalization 的依赖: SELU 的自归一化特性使得网络在训练过程中不需要依赖 Batch Normalization，从而简化了网络结构。\n",
    "\n",
    "适用于深层网络: SELU 特别适合用于深层神经网络，能够显著提高训练效率和模型性能。\n",
    "\n",
    "4. SELU 的缺点\n",
    "对权重初始化敏感: SELU 对权重的初始化要求较高，通常需要使用 LeCun 正态初始化（nn.init.kaiming_normal_）来确保自归一化特性。\n",
    "\n",
    "不适用于所有任务: SELU 在某些任务（如图像分类）中表现优异，但在其他任务（如自然语言处理）中可能不如 ReLU 或其变体。"
   ],
   "id": "52e2dd67be9964b1"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:43.062556Z",
     "start_time": "2025-02-07T01:33:43.052499Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 NeuralNetwork 的类，继承自 nn.Module\n",
    "# 继承 nn.Module 可以使用 PyTorch 提供的神经网络功能\n",
    "class NeuralNetwork(nn.Module):\n",
    "\n",
    "    # 定义类的构造函数，接受一个参数 layers_num，表示隐藏层的数量，默认值为 2。\n",
    "    # 初始化网络的层结构和参数\n",
    "    def __init__(self, layers_num=2):\n",
    "\n",
    "        # 调用父类的构造函数\n",
    "        # 确保 NeuralNetwork 类正确初始化\n",
    "        super().__init__()\n",
    "\n",
    "        # 将 transforms 赋值给类的属性 self.transforms\n",
    "        self.transforms = transforms\n",
    "\n",
    "        # 定义一个 Flatten 层，用于将输入数据展平为一维向量\n",
    "        self.flatten = nn.Flatten()\n",
    "\n",
    "        # 定义一个 Sequential 容器，包含一个全连接层和一个 ReLU 激活函数\n",
    "        # 构建网络的第一层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            nn.SELU(),\n",
    "        )\n",
    "\n",
    "        # 循环添加隐藏层，每层包括一个全连接层和一个 ReLU 激活函数\n",
    "        # 动态构建隐藏层，使网络深度可配置\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"selu\", nn.SELU())  # 这里采用SELU激活函数\n",
    "\n",
    "        # 定义输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "\n",
    "        # 调用 init_weights 方法初始化网络参数\n",
    "        # 避免参数初始值不合适导致训练困难\n",
    "        self.init_weights()\n",
    "\n",
    "        # 定义 init_weights 方法，用于初始化网络参数\n",
    "        # self.modules(): 获取网络中的所有模块\n",
    "        # isinstance(m, nn.Linear): 检查模块是否为全连接层。\n",
    "        # nn.init.xavier_uniform_(m.weight): 使用 Xavier 初始化方法初始化权重。\n",
    "        # nn.init.zeros_(m.bias): 将偏置初始化为 0。\n",
    "        # 合适的参数初始化可以加速模型收敛\n",
    "\n",
    "    def init_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "        # 定义 forward 方法，实现网络的前向传播\n",
    "        # 输入数据经过 transforms 处理后，经过 flatten 层展平为一维向量\n",
    "        # 经过 linear_relu_stack 层，输出网络预测结果\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.transforms(x)\n",
    "        x = self.flatten(x)\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits\n",
    "\n",
    "\n",
    "# 计算并打印模型的参数数量和形状\n",
    "# NeuralNetwork(20).named_parameters(): 获取模型的所有参数及其名称。\n",
    "# np.prod(value.shape): 计算参数的个数（形状的乘积）。\n",
    "# total += np.prod(value.shape): 累加所有参数的数量。\n",
    "total = 0\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")\n",
    "    print(f\"Linear_{idx // 2:>02}\\tshape: {value.shape}\")\n",
    "    total += np.prod(value.shape)\n",
    "total"
   ],
   "id": "2bfa7060ce08fe71",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tshape: torch.Size([100, 784])\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_00\tshape: torch.Size([100])\n",
      "Linear_01\tparamerters num: 10000\n",
      "Linear_01\tshape: torch.Size([100, 100])\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_01\tshape: torch.Size([100])\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tshape: torch.Size([100, 100])\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_02\tshape: torch.Size([100])\n",
      "Linear_03\tparamerters num: 10000\n",
      "Linear_03\tshape: torch.Size([100, 100])\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_03\tshape: torch.Size([100])\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tshape: torch.Size([100, 100])\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_04\tshape: torch.Size([100])\n",
      "Linear_05\tparamerters num: 10000\n",
      "Linear_05\tshape: torch.Size([100, 100])\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_05\tshape: torch.Size([100])\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tshape: torch.Size([100, 100])\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_06\tshape: torch.Size([100])\n",
      "Linear_07\tparamerters num: 10000\n",
      "Linear_07\tshape: torch.Size([100, 100])\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_07\tshape: torch.Size([100])\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tshape: torch.Size([100, 100])\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_08\tshape: torch.Size([100])\n",
      "Linear_09\tparamerters num: 10000\n",
      "Linear_09\tshape: torch.Size([100, 100])\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_09\tshape: torch.Size([100])\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tshape: torch.Size([100, 100])\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_10\tshape: torch.Size([100])\n",
      "Linear_11\tparamerters num: 10000\n",
      "Linear_11\tshape: torch.Size([100, 100])\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_11\tshape: torch.Size([100])\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tshape: torch.Size([100, 100])\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_12\tshape: torch.Size([100])\n",
      "Linear_13\tparamerters num: 10000\n",
      "Linear_13\tshape: torch.Size([100, 100])\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_13\tshape: torch.Size([100])\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tshape: torch.Size([100, 100])\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_14\tshape: torch.Size([100])\n",
      "Linear_15\tparamerters num: 10000\n",
      "Linear_15\tshape: torch.Size([100, 100])\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_15\tshape: torch.Size([100])\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tshape: torch.Size([100, 100])\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_16\tshape: torch.Size([100])\n",
      "Linear_17\tparamerters num: 10000\n",
      "Linear_17\tshape: torch.Size([100, 100])\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_17\tshape: torch.Size([100])\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tshape: torch.Size([100, 100])\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_18\tshape: torch.Size([100])\n",
      "Linear_19\tparamerters num: 10000\n",
      "Linear_19\tshape: torch.Size([100, 100])\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_19\tshape: torch.Size([100])\n",
      "Linear_20\tparamerters num: 1000\n",
      "Linear_20\tshape: torch.Size([10, 100])\n",
      "Linear_20\tparamerters num: 10\n",
      "Linear_20\tshape: torch.Size([10])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "271410"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练",
   "id": "d911b185989182f4"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:43.100431Z",
     "start_time": "2025-02-07T01:33:43.063560Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "# 这是一个装饰器，用于禁用梯度计算。\n",
    "# 在评估模型时，我们不需要计算梯度，因为不会进行反向传播和参数更新。禁用梯度计算可以减少内存消耗并加速计算。\n",
    "@torch.no_grad()\n",
    "# 定义评估函数，接受三个参数：model（要评估的模型）、dataloader（数据加载器，用于提供评估数据）、loss_fct（损失函数）。\n",
    "# 用于评估模型在给定数据集上的性能。\n",
    "# 通过封装评估过程，可以方便地在不同模型和数据集上重复使用。\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    # 初始化三个空列表，分别用于存储每个批次的损失、预测标签和真实标签。\n",
    "    # 用于累积所有批次的损失和标签，以便后续计算平均损失和准确率。\n",
    "    # 累积所有批次的结果可以更准确地反映模型在整个数据集上的性能。\n",
    "    loss_list = []  # 记录损失\n",
    "    pred_list = []  # 记录预测\n",
    "    label_list = []  # 记录标签\n",
    "\n",
    "    # 遍历数据加载器中的每个批次，datas 是输入数据，labels 是对应的真实标签\n",
    "    for datas, labels in dataloader:\n",
    "        # 将输入数据和标签移动到指定的设备（GPU或CPU），转到GPU可以加速计算\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # 将输入数据传递给模型，得到模型的输出 logits（通常是未归一化的预测分数）。\n",
    "        # 模型的前向传播过程，计算输入数据对应的输出。通过模型的输出可以计算损失和预测标签。\n",
    "        logits = model(datas)\n",
    "\n",
    "        # 将当前批次的损失值（转换为 Python 浮点数）添加到 loss_list 中。\n",
    "        # loss.item() 将张量中的单个值提取为 Python 浮点数。\n",
    "        # 累积所有批次的损失值，以便后续计算平均损失。\n",
    "        loss = loss_fct(logits, labels)\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # 通过 argmax 函数获取模型预测的类别标签。axis=-1 表示在最后一个维度上取最大值对应的索引。\n",
    "        # logits 通常是每个类别的分数，argmax 找到分数最高的类别作为预测结果。\n",
    "        # 将模型的输出转换为具体的类别标签，便于与真实标签进行比较。\n",
    "        preds = logits.argmax(axis=-1)\n",
    "\n",
    "        # 将预测标签从 GPU 移动到 CPU，并转换为 NumPy 数组，再转换为 Python 列表，然后添加到 pred_list 中。\n",
    "        # preds.cpu().numpy().tolist() 将张量转换为 Python 列表。\n",
    "        # 累积所有批次的预测标签，以便后续计算准确率。\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    #计算预测标签和真实标签之间的准确率\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "\n",
    "    #返回所有批次的平均损失和准确率。\n",
    "    return np.mean(loss_list), acc"
   ],
   "id": "f61f638900a4b1f3",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Tensorboard 可视化",
   "id": "bf15f06c65aecdc5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:45.502793Z",
     "start_time": "2025-02-07T01:33:43.101435Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir,\n",
    "                                    flush_secs=flush_secs)  # 实例化SummaryWriter, log_dir是log存放路径，flush_secs是每隔多少秒写入磁盘\n",
    "\n",
    "    def draw_model(self, model, input_shape):  #graphs\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))  # 画模型图\n",
    "\n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\",\n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "        )  # 画loss曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )  # 画acc曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "        )  # 画lr曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss,把loss，val_loss取掉，画loss曲线\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)  # 画loss曲线\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)  # 画acc曲线\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)  # 画lr曲线\n"
   ],
   "id": "8c2df3129dcef4b6",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 保存最好模型",
   "id": "e90b3a3c89900c08"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:45.508821Z",
     "start_time": "2025-02-07T01:33:45.503821Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 SaveCheckpointsCallback 的类。\n",
    "# 该类用于在训练过程中保存模型的检查点。封装保存检查点的逻辑，方便在训练过程中调用\n",
    "class SaveCheckpointsCallback:\n",
    "    \"\"\"\n",
    "    Callback to save model checkpoints during training.\n",
    "    \"\"\"\n",
    "\n",
    "    #定义类的构造函数，接受以下参数：\n",
    "    # save_dir: 检查点保存的目录。\n",
    "    # save_step: 每隔多少步保存一次检查点，默认值为 500。\n",
    "    # save_best_only: 是否只保存性能最好的检查点，默认值为 True\n",
    "    # 原理：初始化回调类的参数和状态\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "\n",
    "        # 初始化一个变量 best_metrics，用于记录当前最好的性能指标值，初始值为 -1\n",
    "        # 原理: 用于比较当前模型的性能是否优于之前保存的模型,当 save_best_only 为 True 时，只保存性能最好的模型\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # 检查保存目录是否存在，如果不存在则创建该目录\n",
    "        # os.path.exists()用于判断路径是否存在, os.mkdir()用于创建目录\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    # 定义 __call__ 方法，使类的实例可以像函数一样调用。参数包括：\n",
    "    # step: 当前训练的步数。\n",
    "    # state_dict: 模型的状态字典（包含模型参数）。\n",
    "    # metric: 当前模型的性能指标值（如验证集准确率），默认为 None\n",
    "    # 在训练过程中定期调用该方法，保存检查点\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "\n",
    "        # 检查当前步数是否是 save_step 的倍数，如果不是则直接返回\n",
    "        # 控制保存检查点的频率，避免频繁保存\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        # 检查是否只保存性能最好的检查点\n",
    "        # 根据 save_best_only 的值决定保存策略,提供两种保存策略：定期保存和只保存最佳模型\n",
    "        if self.save_best_only:\n",
    "\n",
    "            # 如果 save_best_only 为 True，则要求 metric 不能为 None。\n",
    "            # 原理: 使用 assert 断言确保 metric 有值。如果 metric 为 None，无法判断模型性能是否更好，因此需要提前检查\n",
    "            assert metric is not None\n",
    "\n",
    "            # 检查当前模型的性能指标是否优于之前保存的最佳模型\n",
    "            # 只保存性能更好的模型，避免保存性能下降的模型\n",
    "            if metric >= self.best_metrics:\n",
    "                # 将模型的状态字典保存到指定目录下的 best.ckpt 文件中\n",
    "                # 使用 torch.save 保存模型参数。保存当前性能最好的模型，方便后续加载和使用\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "\n",
    "                # 更新 best_metrics 为当前模型的性能指标值\n",
    "                self.best_metrics = metric\n",
    "\n",
    "        # 如果 save_best_only 为 False，则执行以下逻辑\n",
    "        # 定期保存检查点，不关心模型性能是否更好\n",
    "        else:\n",
    "\n",
    "            # 将模型的状态字典保存到指定目录下，文件名为当前步数\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))"
   ],
   "id": "a6f18fc340403b57",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 早停",
   "id": "4720c83f1ce2c823"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:45.513886Z",
     "start_time": "2025-02-07T01:33:45.509862Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 EarlyStopCallback 的类.用于监控模型在验证集上的性能，并在性能不再提升时触发早停。\n",
    "# 封装早停的逻辑，方便在训练过程中调用\n",
    "class EarlyStopCallback:\n",
    "\n",
    "    # 定义类的构造函数，接受以下参数\n",
    "    # patience: 容忍的轮次数，默认值为 5。如果在 patience 轮内性能没有提升，则触发早停。\n",
    "    # min_delta: 性能提升的最小阈值，默认值为 0.01。只有当性能提升超过该阈值时，才认为模型有改进。\n",
    "    # 初始化早停回调的参数和状态\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "\n",
    "        self.best_metric = -1  # 用于比较当前模型的性能是否优于之前的最佳性能\n",
    "\n",
    "        # 初始化一个计数器 counter，用于记录性能没有提升的连续轮次数，初始值为 0\n",
    "        # 当性能没有提升时，计数器增加；当性能提升时，计数器重置,用于判断是否达到了早停的条件\n",
    "        self.counter = 0\n",
    "\n",
    "    # 训练过程中定期调用该方法，更新早停状态\n",
    "    def __call__(self, metric):\n",
    "\n",
    "        # 检查当前性能指标是否比之前的最佳性能提升了至少 min_delta\n",
    "        # 避免微小的波动触发早停,当性能有显著提升时，才认为模型有改进\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "\n",
    "            self.best_metric = metric  # 记录当前最佳性能\n",
    "            self.counter = 0  # 性能有提升时，重置计数器,重新开始计算性能没有提升的连续轮次数\n",
    "\n",
    "        # 性能没有提升时，增加计数器\n",
    "        else:\n",
    "            self.counter += 1  # 记录性能没有提升的连续轮次数\n",
    "\n",
    "    # 定义一个只读属性 early_stop，用于判断是否触发早停。\n",
    "    # 使用 @property 装饰器将方法转换为属性。方便外部代码通过属性访问早停状态。\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "\n",
    "        # 检查计数器 counter 是否大于或等于 patience\n",
    "        # 提供早停的触发条件\n",
    "        return self.counter >= self.patience"
   ],
   "id": "4d832bdbea1d7eec",
   "outputs": [],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:45.521894Z",
     "start_time": "2025-02-07T01:33:45.514891Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 training 的函数，用于训练模型。参数包括：\n",
    "# model: 要训练的模型。\n",
    "# train_loader: 训练数据的数据加载器。\n",
    "# val_loader: 验证数据的数据加载器。\n",
    "# epoch: 训练的轮数。\n",
    "# loss_fct: 损失函数。\n",
    "# optimizer: 优化器。\n",
    "# eval_step: 每隔多少步评估一次验证集性能，默认值为 500。\n",
    "# 该函数通过遍历训练数据，更新模型参数，并定期评估验证集性能。封装训练过程，方便重复使用\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    # 初始化一个字典 record_dict，用于记录训练和验证过程中的损失和准确率。\n",
    "    # 通过记录训练和验证的性能，可以分析模型的训练过程。方便后续绘制训练曲线或分析模型表现。\n",
    "    record_dict = {\n",
    "        \"train\": [],  # \"train\": 存储训练集的损失和准确率。\n",
    "        \"val\": []  # \"val\": 存储验证集的损失和准确率。\n",
    "    }\n",
    "\n",
    "    # 初始化一个全局步数计数器 global_step，用于记录当前训练的步数。\n",
    "    # 步数用于控制何时评估验证集性能。通过步数而不是轮数来控制评估频率，更灵活。\n",
    "    global_step = 0\n",
    "\n",
    "    # 将模型设置为训练模式。在训练模式下，模型会启用一些特定于训练的功能（如 Dropout 和 BatchNorm）。\n",
    "    # 确保模型在训练时行为正确。\n",
    "    model.train()\n",
    "\n",
    "    # 使用 tqdm 创建一个进度条，总长度为 epoch * len(train_loader)，即总训练步数。\n",
    "    # tqdm 是一个进度条库，用于显示训练进度。\n",
    "    # 提供可视化的训练进度，方便监控训练过程。\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "\n",
    "        # 外层循环，遍历每个训练轮次。每个轮次会遍历整个训练数据集一次。\n",
    "        # 多轮训练可以提高模型的性能。\n",
    "        for epoch_id in range(epoch):\n",
    "\n",
    "            # 内层循环，遍历训练数据加载器中的每个批次。\n",
    "            for datas, labels in train_loader:\n",
    "\n",
    "                # 将输入数据和标签移动到指定的设备（GPU或CPU），转到GPU可以加速计算\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # 清除优化器中之前的梯度。\n",
    "                # PyTorch 会累积梯度，因此在每次反向传播前需要清除之前的梯度。避免梯度累积导致错误的参数更新。\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                logits = model(datas)  # 模型前向计算\n",
    "                loss = loss_fct(logits, labels)  # 计算损失\n",
    "\n",
    "                # 计算损失相对于模型参数的梯度。\n",
    "                # 反向传播算法，通过链式法则计算梯度。梯度用于更新模型参数，以最小化损失。\n",
    "                loss.backward()\n",
    "\n",
    "                # 使用优化器更新模型参数。\n",
    "                optimizer.step()\n",
    "\n",
    "                preds = logits.argmax(axis=-1)  # 通过 argmax 函数获取模型预测的类别标签。\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())  # 计算当前批次的准确率\n",
    "                loss = loss.cpu().item()  # 将损失值从 GPU 移动到 CPU，并转换为 Python 浮点数。方便记录和打印损失值。\n",
    "\n",
    "                # 将当前批次的损失、准确率和步数记录到 record_dict[\"train\"] 中\n",
    "                # 累积训练过程中的性能指标。方便后续分析训练过程\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # 每隔 eval_step 步评估一次验证集性能。\n",
    "                # 使用 global_step 控制评估频率。定期评估验证集性能，避免过拟合。\n",
    "                if global_step % eval_step == 0:\n",
    "                    # 将模型设置为评估模式\n",
    "                    model.eval()\n",
    "\n",
    "                    # 调用 evaluating 函数计算验证集的损失和准确率\n",
    "                    # 在验证集上评估模型性能。验证集性能反映了模型的泛化能力。\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "\n",
    "                    # 将验证集的损失、准确率和步数记录到 record_dict[\"val\"] 中。\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "\n",
    "                    # 将模型设置为训练模式\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        # 调用 tensorboard 回调函数，记录训练过程中的关键指标\n",
    "                        tensorboard_callback(\n",
    "                            global_step,  # 当前训练的全局步数，用于在 TensorBoard 中标识不同的训练阶段\n",
    "                            loss=loss, val_loss=val_loss,  # 记录训练集和验证集的损失值，用于监控模型在训练和验证集上的表现\n",
    "                            acc=acc, val_acc=val_acc,  # 记录训练集和验证集的准确率，用于监控模型的分类性能\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],  # 取出当前学习率，用于监控学习率的变化，确保学习率调整策略正常工作\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        # 调用保存模型权重的回调函数，保存当前模型的权重\n",
    "                        save_ckpt_callback(\n",
    "                            global_step,  # 当前训练的全局步数，用于标识保存的模型权重对应的训练阶段\n",
    "                            model.state_dict(),  # 保存模型的当前状态字典（即模型的所有参数），以便后续可以恢复模型\n",
    "                            metric=val_acc  # 使用验证集的准确率作为指标，判断是否保存当前模型（通常只保存性能最好的模型）\n",
    "                        )\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        # 调用早停回调函数，监控验证集准确率是否不再提升\n",
    "                        early_stop_callback(val_acc)  # 传入验证集准确率，用于判断是否满足早停条件\n",
    "                        if early_stop_callback.early_stop:  # 检查是否触发了早停条件\n",
    "                            # 如果触发了早停条件，打印提示信息并结束训练\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict  # 返回训练记录字典，包含训练过程中的关键指标\n",
    "\n",
    "                # 增加全局步数计数器\n",
    "                # 记录当前训练的步数,控制评估频率和记录训练进度\n",
    "                global_step += 1\n",
    "\n",
    "                # 更新进度条\n",
    "                pbar.update(1)\n",
    "\n",
    "                # 在进度条中显示当前训练的轮次。\n",
    "                # 更新进度条的后缀信息。方便监控训练进度。\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    # 返回记录的训练和验证性能的字典,包含训练和验证过程中的损失和准确率\n",
    "    return record_dict"
   ],
   "id": "a452d95c803a8a58",
   "outputs": [],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:31.515266Z",
     "start_time": "2025-02-07T01:57:31.451401Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 100\n",
    "\n",
    "# 实例化NeuralNetwork类，创建一个神经网络模型对象\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "\n",
    "# 定义了一个损失函数使用的是交叉熵损失函数，这是分类问题中常用的损失函数。\n",
    "# CrossEntropyLoss 结合了 Softmax 激活函数和 Log Loss，内部先做softmax，再计算交叉熵，用于多类别分类问题。\n",
    "# 输入是未经过 Softmax 处理的 logits（原始预测分数），而目标标签应该是类别的索引\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "\n",
    "# 优化器：用于更新模型的参数。\n",
    "# 这里使用的是 SGD（随机梯度下降，Stochastic Gradient Descent）优化算法。通过对每个数据点的梯度进行更新，快速地调整模型参数。\n",
    "# model.parameters()：这一部分是传入模型的所有参数，优化器将会基于这些参数计算梯度并进行更新。\n",
    "# lr：学习率，控制参数更新的步长。学习率越小，更新越慢；学习率越大，可能会导致训练不稳定。0.001 是一个比较常见的初始学习率。\n",
    "# momentum：动量是为了加速 SGD，避免在训练过程中振荡。动量值通常在 0 到 1 之间，0.9 是一个常用的选择。动量帮助优化器在上一次梯度的方向上继续前进，从而使得优化过程更为稳定。\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 实例化\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. 保存最佳模型\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/selu\", save_best_only=True)\n",
    "# 3. 早停\n",
    "early_stop_callback = EarlyStopCallback(patience=10)"
   ],
   "id": "55fd51912633ca11",
   "outputs": [],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T02:19:47.527188Z",
     "start_time": "2025-02-07T01:57:32.065645Z"
    }
   },
   "cell_type": "code",
   "source": [
    "record = training(\n",
    "    model,  # 要训练的模型\n",
    "    train_loader,  # 训练数据的数据加载器\n",
    "    val_loader,  # 验证数据的数据加载器\n",
    "    epoch,  # 训练的轮数\n",
    "    loss_fct,  # 损失函数\n",
    "    optimizer,  # 优化器\n",
    "    tensorboard_callback=None,  # tensorboard 可视化\n",
    "    save_ckpt_callback=save_ckpt_callback,  # 保存最佳模型\n",
    "    early_stop_callback=early_stop_callback,  # 早停\n",
    "    eval_step=len(train_loader)  # 每隔多少步评估一次验证集性能\n",
    ")"
   ],
   "id": "a715ad4ee2ef44c8",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "25405920c11348359e2dc07353860fa1"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 23 / global_step 86250\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T02:19:47.725813Z",
     "start_time": "2025-02-07T02:19:47.528195Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "# 定义一个名为 plot_learning_curves 的函数，接受以下参数：\n",
    "# record_dict: 包含训练和验证记录的字典。\n",
    "# sample_step: 对训练数据进行采样的步长，默认值为 500。\n",
    "# 该函数用于可视化训练和验证过程中的性能指标。\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # 将训练记录转换为 Pandas DataFrame，并设置 step 列为索引。然后对数据进行采样，步长为 sample_step\n",
    "    # pd.DataFrame(record_dict[\"train\"]): 将训练记录转换为 DataFrame。\n",
    "    # .set_index(\"step\"): 将 step 列设置为索引。\n",
    "    # .iloc[::sample_step]: 对数据进行采样，每隔 sample_step 步取一个样本。\n",
    "    # 减少数据点的数量，使曲线更清晰，同时保留趋势\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "\n",
    "    # 将验证记录转换为 Pandas DataFrame，并设置 step 列为索引\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # 计算训练 DataFrame 的列数，即需要绘制的性能指标数量\n",
    "    # 确定需要创建的子图数量\n",
    "    fig_num = len(train_df.columns)\n",
    "\n",
    "    # 创建一个包含 fig_num 个子图的图形\n",
    "    # 为每个性能指标创建一个子图，方便对比\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "\n",
    "    # 遍历训练 DataFrame 的每一列（即每个性能指标）。\n",
    "    # 使用 enumerate 获取列名和索引\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        # train_df.index: x 轴数据（训练步数）。\n",
    "        # train_df[item]: y 轴数据（性能指标值）。\n",
    "        # label=f\"train_{item}\": 设置曲线的标签。\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "\n",
    "        axs[idx].grid()  # 在当前子图上添加网格线\n",
    "        axs[idx].legend()  # 在当前子图上添加图例\n",
    "\n",
    "        # 生成 x 轴的刻度数据，从 0 到最大步数，步长为 5000\n",
    "        x_data = range(0, train_df.index[-1], 5000)\n",
    "\n",
    "        axs[idx].set_xticks(x_data)  # 设置 x 轴的刻度位置\n",
    "\n",
    "        # 设置 x 轴的刻度标签，将步数转换为“k”格式（如 5000 → \"5k\"）\n",
    "        # map(lambda x: f\"{int(x / 1000)}k\", x_data): 将刻度数据转换为“k”格式。\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x / 1000)}k\", x_data))\n",
    "\n",
    "        axs[idx].set_xlabel(\"step\")  # 设置 x 轴的标签为“step”\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)"
   ],
   "id": "a74c32989540c34",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### selu激活函数，可以加速收敛，效果相对于relu更好",
   "id": "13e5a3c3a4449635"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T02:19:49.127893Z",
     "start_time": "2025-02-07T02:19:47.726939Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/selu/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "id": "c20bcbde0c67ab40",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3760\n",
      "accuracy: 0.8842\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:45:53.728240Z",
     "start_time": "2025-02-07T01:45:53.727239Z"
    }
   },
   "cell_type": "code",
   "source": "",
   "id": "4a62054811a449ea",
   "outputs": [],
   "execution_count": null
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
